/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package tetris_invader.util;

import java.io.Serializable;

/**
 * Classe criada especialmente para manipulacao de forcas que atuam nos objetos
 * da fase(velocidade e aceleracao)
 */
public class Pair implements Serializable {

    private float x;
    private float y;

    /**
     * Construtor padrao.<br>
     * Inicializa as coordenadas como zero.
     */
    public Pair() {
        this.x = 0;
        this.y = 0;
    }

    /**
     * Construtor<br>
     * Inicializa as variaveis de acordo com os parametros de entrada
     * @param x Novo valor para x da classe
     * @param y Novo valor para y da classe
     */
    public Pair(float x, float y) {
        this.x = x;
        this.y = y;
    }

    public float getX() {
        return x;
    }

    public void setX(float x) {
        this.x = x;
    }

    public float getY() {
        return y;
    }

    public void setY(float y) {
        this.y = y;
    }

    /**
     * Verifica se somente o valor de <u>x</u> é zero.
     * @return <i>true</i> se x for zero.
     */
    public boolean isXzero() {
        return (this.x == 0);
    }
    
    /**
     * Verifica se somente o valor de <u>y</u> é zero
     * @return <i>true</i> se y for zero.
     */
    public boolean isYzero() {
        return (this.y == 0);
    }

    /**
     * Soma ao par o valor dado no parâmetro.<br>
     * Funciona tambem com valores negativos.
     * @param p Valor a ser somado.
     */
    public void sum(Pair p) {
        this.x += p.getX();
        this.y += p.getY();
    }

    /**
     * Subtrai do par o valor no parametro.<br>
     * Funciona com valores negativos no parametro.
     * @param p Valor a ser subtraído
     */
    public void subtract(Pair p) {
        this.x -= p.getX();
        this.y -= p.getY();
    }

    /**
     * Verifica se alguma das coordenadas é menor que o valor do parametro da entrada.
     * @param f Valor a ser comparado
     * @return <i>true</i> se alguma das coordenada é menor.<br>
     * <i>false</i> caso contrario.
     */
    public boolean lessThen(float f) {
        return (Math.abs(this.x) < f && Math.abs(this.y) < f);
    }

    /**
     * Verifica se o par de valores é zero
     * @return <i>true</i> se ambos forem zero
     */
    public boolean zero() {
        return ((this.x == 0.0) && (this.y == 0.0));
    }

    /**
     * Verifica se alguma das coordenadas é maior que o valor do parametro da entrada.
     * @param f Pair a ser comparado
     * @return <i>true</i> se alguma das coordenada é maior.<br>
     * <i>false</i> caso contrario.
     *
     */
    public boolean greatThen(float f) {
        return (Math.abs(this.x) > f && Math.abs(this.y) > f);
    }

    /**
     * Inverte o valor das coordenadas, tornando-as negativas se forem positivas
     * e vice versa.
     */
    public void invert() {
        this.x = -this.x;
        this.y = -this.y;
    }

    /**
     * Inverte apenas o valor da coordenada X
     */
    public void invertX() {
        this.x = -this.x;
    }
    /**
     * Inverte apenas o valor da coordenada Y
     */
    public void invertY() {
        this.y = -this.y;
    }

    /**
     * Compara o valor da coordenada X com algum outro valor dado no parametro
     * de comparacao.
     *
     * @param x Parametro de comparacao
     * @return Valor maior que zero se for maior que o parametro de comparacao<br>
     * Valor menor que zero se for menor<br>
     * Zero se for igual
     */
    public int xGreatThen(float x) {
        if (this.x > x) {
            return 1;
        } else if (this.x < x) {
            return -1;
        }
        return 0;
    }

    /**
     * Compara o valor da coordenada Y com algum outro valor dado no parametro
     * de comparacao.
     *
     * @param y Parametro de comparacao
     * @return Valor maior que zero se for maior que o parametro de comparacao<br>
     * Valor menor que zero se for menor<br>
     * Zero se for igual
     */
    public int yGreatThen(float y) {
        if (this.y > y) {
            return 1;
        } else if (this.y < y) {
            return -1;
        }
        return 0;
    }

}
